package com.atguigu.gulimall.search.thread;

import java.util.concurrent.*;

/**
 * @Author: Zjn ; Bring it on !!!
 * @Date: 2021/11/11 0011 15:23
 * Note:
 */
public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(10);

    /**
     * 线程串行化
     * 1)thenRunAsync: 不能获取到上一步的执行结果(无返回值)
     * 2)thenAcceptAsync: 可以获取到上一步的返回结果(无返回值)
     * 3)thenApply:能接收上一步返回结果，且有返回值
     *
     * 1)runAfterBothAsync:组合两个future，不需要获取future的结果，只需两个future处理完任务后处理该任务
     * 2)thenAcceptBothAsync:组合两个future，获取两个future任务的返回结果，然后处理该任务，没有返回值
     * 2)thenCombineAsync:组合两个future，获取两个future任务的返回结果，并返回当前任务的返回值
     */
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main...start...");
/*        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
        }, executor);*/


/*        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
            return i;
        }, executor).whenComplete((res,exception)->{
            //虽然能得到异常信息，但是没法修改返回数据
            System.out.println("异步任务成功完成了。。。。结果是:"+res+";异常是："+exception);
        }).exceptionally(throwable -> {
            //可以感知异常，同时返回默认值
            return 10;
        });
        Integer integer = future.get();*/


        /*CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("运行结果:" + i);
            return i;
        }, executor).thenApplyAsync((res->{
            System.out.println("任务2启动了。。。"+res);
          return "Hello "+ res;
        }),executor);*/



        /*CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1结束:" + i);
            return i;
        }, executor);

        CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            System.out.println("任务2结束:");
            return "Hello";
        }, executor);*/



/*        CompletableFuture<Void> future = future01.runAfterBothAsync(future02, () -> {
            System.out.println("任务3开始。。");
        }, executor);*/

        /*CompletableFuture<Void> future = future01.thenAcceptBothAsync(future02, (f1,f2) -> {
            System.out.println("任务3开始。。"+f1+"------------>"+f2);
        }, executor);*/

        /*CompletableFuture<String> future = future01.thenCombineAsync(future02, (f1, f2) -> {
            String s = f1 + "+" + f2 + "---->hello";
            return s;
        }, executor);*/

        /**
         * runAfterEither:两个任务有一个执行完成，不需要获取future的结果，处理任务，也没有返回值
         * acceptEither:两个任务有一个执行完成，获取他的返回值，处理任务，没有新的返回值
         * applyToEither：两个任务有一个执行完成，获取他的返回值，处理任务并有新的返回值
         */

        System.out.println("main...end..." );
    }
}
